home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / case.h < prev    next >
C/C++ Source or Header  |  1999-05-14  |  5KB  |  178 lines
  1. // $Id: case.h,v 1.3 1999/01/25 20:00:27 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10.  
  11. #ifndef case_INCLUDED
  12. #define case_INCLUDED
  13.  
  14. #include "config.h"
  15. #include "bool.h"
  16. #ifndef __amigaos__
  17. #include <wchar.h>
  18. #endif
  19.  
  20. //
  21. // NOTE that this class is hard-wired to work on an ASCII machine.
  22. // To make it universal, one should uncomment the constructor and
  23. // make the array "lower" non-static. In such a case, each object
  24. // of type Case that is declared will allocate its own "lower" array.
  25. //
  26. class Case
  27. {
  28.     static char lower[128];
  29.     static char upper[128];
  30.  
  31. public:
  32.  
  33.     static inline bool IsAsciiLower(char c)       { return c == lower[c]; }
  34.     static inline char ToAsciiLower(char c)       { return (c & (char) 0x80) ? c : lower[c]; }
  35.     static inline wchar_t ToAsciiLower(wchar_t c) { return (c < 128 ? (wchar_t) lower[c] : c); }
  36.  
  37.     static inline bool IsAsciiUpper(char c)       { return c == upper[c]; }
  38.     static inline char ToAsciiUpper(char c)       { return (c & (char) 0x80) ? c : upper[c]; }
  39.     static inline wchar_t ToAsciiUpper(wchar_t c) { return (c < 128 ? (wchar_t) upper[c] : c); }
  40.  
  41.     static inline bool IsAsciiAlpha(char c)    { return (c == lower[c] || c == upper[c]); }
  42.     static inline bool IsAsciiAlpha(wchar_t c) { return (c == lower[c] || c == upper[c]); }
  43.  
  44.     //
  45.     // Find the position of the first occurrence of a character within a string.
  46.     // If the character is not foud, return -1.
  47.     //
  48.     static inline int Index(char *s, wchar_t c)
  49.     {
  50.         for (int i = 0; *s != U_NULL; i++, s++)
  51.         {
  52.             if (*s == c)
  53.                 return i;
  54.         }
  55.         return -1;
  56.     }
  57.  
  58.     static inline int Index(wchar_t *s, wchar_t c)
  59.     {
  60.         for (int i = 0; *s != U_NULL; i++, s++)
  61.         {
  62.             if (*s == c)
  63.                 return i;
  64.         }
  65.         return -1;
  66.     }
  67.  
  68.     //
  69.     // Compare two character strings segments of length n in the strings
  70.     // s1 and s2 to check whether or not they are equal. Note that unlike
  71.     // the builtin function "strncmp" the comparison always checks n characters
  72.     // and does not terminate if it encounters a NULL character. 
  73.     //
  74.     static inline bool StringSegmentEqual(char *s1, const char *s2, int n)
  75.     {
  76.         for (int i = 0; i < n; i++)
  77.         {
  78.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  79.                 return false;
  80.         }
  81.         return true;
  82.     }
  83.  
  84.     static inline bool StringSegmentEqual(wchar_t *s1, const char *s2, int n)
  85.     {
  86.         for (int i = 0; i < n; i++)
  87.         {
  88.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  89.                 return false;
  90.         }
  91.         return true;
  92.     }
  93.  
  94.     static inline bool StringSegmentEqual(char *s1, const wchar_t *s2, int n)
  95.     {
  96.         for (int i = 0; i < n; i++)
  97.         {
  98.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  99.                 return false;
  100.         }
  101.         return true;
  102.     }
  103.  
  104.     static inline bool StringSegmentEqual(wchar_t *s1, const wchar_t *s2, int n)
  105.     {
  106.         for (int i = 0; i < n; i++)
  107.         {
  108.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  109.                 return false;
  110.         }
  111.         return true;
  112.     }
  113.  
  114.  
  115.     //
  116.     // Compare two null-terminated character strings, s1 and s2
  117.     // to check whether or not they are equal.
  118.     //
  119.     static inline bool StringEqual(char *s1, const char *s2)
  120.     {
  121.         int i;
  122.         for (i = 0; s1[i] && s2[i]; i++)
  123.         {
  124.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  125.                 return false;
  126.         }
  127.         return (s1[i] == s2[i]);
  128.     }
  129.  
  130.     static inline bool StringEqual(wchar_t *s1, const char *s2)
  131.     {
  132.         int i;
  133.         for (i = 0; s1[i] && s2[i]; i++)
  134.         {
  135.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  136.                 return false;
  137.         }
  138.         return (s1[i] == s2[i]);
  139.     }
  140.  
  141.     static inline bool StringEqual(char *s1, const wchar_t *s2)
  142.     {
  143.         int i;
  144.         for (i = 0; s1[i] && s2[i]; i++)
  145.         {
  146.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  147.                 return false;
  148.         }
  149.         return (s1[i] == s2[i]);
  150.     }
  151.  
  152.     static inline bool StringEqual(wchar_t *s1, const wchar_t *s2)
  153.     {
  154.         int i;
  155.         for (i = 0; s1[i] && s2[i]; i++)
  156.         {
  157.             if (ToAsciiLower(s1[i]) != ToAsciiLower(s2[i]))
  158.                 return false;
  159.         }
  160.         return (s1[i] == s2[i]);
  161.     }
  162.  
  163.  
  164. //  Lcase()
  165. //  {
  166. //      for (int c = 0; c < 256; c++)
  167. //      {
  168. //          if (isupper(c))
  169. //               lower[c] = tolower(c);
  170. //          else if (islower(c))
  171. //               upper[c] = toupper(c);
  172. //          else lower[c] = upper[c] = c;
  173. //      }
  174. //  }
  175. };
  176.  
  177. #endif /* case_INCLUDED */
  178.